#1、输入数字n，输出n天前的日期（time或者datatime模块）
def get_predays(n):
    import datetime
    date = datetime.date
    today = date.today()
    interval = datetime.timedelta(days=n)
    return today - interval
print(get_predays(2))
#2、输出指定文件夹下有哪些文件或文件夹（实现ls命令， os）
def get_ls(path):
    import os
    if os.path.isdir(path):
        for i in os.listdir(path):
        #把路径下的文件或文件夹以列表的形式封装再遍历
            print(i)
# get_ls("E:\sanchuang\晔哥学习笔记")
#3、列表去重，并且从小到大排序
lst = [1, 1, 3, 4, 7, 8, 4, 3, 6, 0, 2, 2]
lst1 = sorted(set(lst))
print(lst)
print(lst1)
#4、如何在一个函数内部修改全局变量
a = 10
print(a, id(a), 1)
def update_a():
    global a
    a = 20
    print(a, id(a), 2)
update_a()
print(a, id(a), 3)
#5、如何跨模块共享全局变量
# 1. Import配置文件时，不要from xxx import *, 而要import config.py
# 2. 在config.py文件中，用set_xxxValue()和get_xxxValue来提供外部访问接口，这个好处是，可以让全局变量在每次调用的时候都能得到刷新
# 3. 其他文件使用get_xxxValue()获取到全局变量的最新值。

#6、python的基本数据类型有哪些？
#number(数字)、string(字符串)、tuple(元组)、list(列表)、set(集合)、dictionary(字典)
# 前三种为不可变数据(不可变数据类型在第一次声明赋值声明的时候, 会在内存中开辟一块空间, 用来存放这个变量被赋的值,
# 而这个变量实际上存储的, 并不是被赋予的这个值, 而是存放这个值所在空间的内存地址, 通过这个地址, 变量就可以在内存
# 中取出数据了. 所谓不可变就是说, 我们不能改变这个数据在内存中的值, 所以当我们改变这个变量的赋值时, 只是在内存中
# 重新开辟了一块空间, 将这一条新的数据存放在这一个新的内存地址里, 而原来的那个变量就不在引用原数据的内存地址而转为
# 引用新数据的内存地址了)，后三种为可变数据。
# —————————————
#7、python中生成随机整数（1-10），随机小数（1-10），随机小数（0-1）的方法
def random_test():
    import random
    print("随机整数(1-10):" + str(random.randint(1,10)))
    print("随机小数(1-10):" + str(random.uniform(1,10)))
    print("随机小数(0-1 ):" + str(random.random()))
random_test()

#8、python中哪些是可变数据类型，哪些是不可变数据类型
#可变数据类型：字典、列表、集合
#不可变数据类型：整数、字符串、元组

#9、a+=1与a=a+1有什么区别
# 对于可变数据类型：a+=1直接在原内存地址上操作，而a=a+1会开辟信的内存空间
# 对于不可变数据类型，两者都会开辟新的内存空间

#10、什么是pep8？说出5点它的标准
# 缩进，每一级缩进使用4个空格
# 空行:顶层函数和类的定义，前后用两个空行隔开。类里的方法定义用一个空行隔开。
# 命名约定:1、类名的首字母大写  2、函数名因该小写  3、永远不要使用字母‘l’（小写的L），‘O’（大写的O），或者‘I’（大写的I）作为单字符变量名
# 函数参数相关：1、实例方法的第一个参数总是 self    2、类的静态方法第一个参数总是 cls
# import：1、先导入Python自带的标准库 os sys time等 2、再导入第三方库 cv2,django,flask等 3、最后导入 本地文件、模块

#11、给定一个字符串，找出字符串第一个重复的字符
def string_s():
    str1 = input("请输入一个字符串：")
    dict1 = {}
    for i in str1:
        if i not in dict1:
            dict1[i] = 1
        else:
            print("第一个重复的字符是："+i)
            break

def lst_(str1):
    lst = []
    for i in str1:
        if i in lst:
            print("第一个重复的字符是："+i)
        else:
            lst.append(i)
lst_('jfklaj')

# string_s()
#12、简述深拷贝与浅拷贝
# 1、深浅拷贝都是对象的拷贝，都会生成一个看起来相同的对象，他们的本质区别是拷贝出来的对象的地址
# 是否和原对象一样，也就是地址的复制还是值的复制。
# 2、浅拷贝：浅拷贝仅仅是指向被复制的内存地址，如果源地址中对象改变了，那么浅拷贝复制出来的对象也会相应改变。
# 3、深拷贝：深拷贝出来的对象会在计算机中开辟一块新的内存地址用于存放复制的对象，原对象数据发生改变不会影响拷贝后的对象
# 总结：容器中套容器的对象需要深拷贝

#13、简述python内存机制
# python内存管理：
# 1、引用计数-->为主
# 2、垃圾回收:分代回收,标记清除
# 3、内存池管理
# 引用计数
# 当有新的引用指向的时候，引用计数+1
# 当有无效的引用发生的时候，引用计数-1
# 当对象的引用计数为0的时候，销毁对象
#14、使用python实现冒泡排序，快速排序
def bubblesort(list1):
    if list1 != None:
        if len(list1) == 1:
            pass
        else:
            for i in range(len(list1)):
                for j in range(len(list1)-1):
                    if list1[j] > list1[j+1]:
                        temp = list1[j]
                        list1[j] = list1[j+1]
                        list1[j+1] = temp
            print(list1)
bubblesort([2,3,7,1,0,6,4,9])

def quick_sort(array, start, end):
    if start > end:
        return
    left = start
    right = end
    mid = array[left]
    while left < right:
        while left < right and array[right] >= mid:
            right -= 1
        array[left] = array[right]
        while left < right and array[left] < mid:
            left += 1
        array[right] = array[left]
    array[left] = mid
    quick_sort(array, start, left-1)
    quick_sort(array, left+1, end)
array = [3,1,5,7,3,2,8,9,4,10]
quick_sort(array, 0, len(array)-1)
print(array)


#15、验证一个字符串是否属于回文（从左到右，从右到左都是一样）
def huiwen():
    str1 = input("请输入一个字符串：")
    lst1 = list(str1)
    if lst1[::-1] == lst1:
        print("该字符串属于回文")
    else:
        print("该字符串不属于回文")